home *** CD-ROM | disk | FTP | other *** search
/ T&A 2 the Maxx 3 / T and A 2 The Maxx Number 3.iso / viewers / unixview / xgiftar.z / xgiftar / bright.c next >
C/C++ Source or Header  |  1991-05-20  |  6KB  |  287 lines
  1. /* bright.c
  2.  *
  3.  * miscellaneous colormap altering functions
  4.  *
  5.  * jim frost 10.10.89
  6.  *
  7.  * Copyright 1989, 1991 Jim Frost.
  8.  * See included file "copyright.h" for complete copyright information.
  9.  */
  10.  
  11. #include "copyright.h"
  12. #include "image.h"
  13.  
  14. /* alter an image's brightness by a given percentage
  15.  */
  16.  
  17. void brighten(image, percent, verbose)
  18.      Image        *image;
  19.      unsigned int  percent;
  20.      unsigned int  verbose;
  21. { int          a;
  22.   unsigned int newrgb;
  23.   float        fperc;
  24.   unsigned int size;
  25.   byte        *destptr;
  26.  
  27.   goodImage(image, "brighten");
  28.   if (BITMAPP(image)) /* we're AT&T */
  29.     return;
  30.  
  31.   if (verbose) {
  32.     printf("  Brightening colormap by %d%%...", percent);
  33.     fflush(stdout);
  34.   }
  35.  
  36.   fperc= (float)percent / 100.0;
  37.  
  38.   switch (image->type) {
  39.   case IRGB:
  40.     for (a= 0; a < image->rgb.used; a++) {
  41.       newrgb= *(image->rgb.red + a) * fperc;
  42.       if (newrgb > 65535)
  43.     newrgb= 65535;
  44.       *(image->rgb.red + a)= newrgb;
  45.       newrgb= *(image->rgb.green + a) * fperc;
  46.       if (newrgb > 65535)
  47.     newrgb= 65535;
  48.       *(image->rgb.green + a)= newrgb;
  49.       newrgb= *(image->rgb.blue + a) * fperc;
  50.       if (newrgb > 65535)
  51.     newrgb= 65535;
  52.       *(image->rgb.blue + a)= newrgb;
  53.     }
  54.     break;
  55.  
  56.   case ITRUE:
  57.     size= image->width * image->height * 3;
  58.     destptr= image->data;
  59.     for (a= 0; a < size; a++) {
  60.       newrgb= *destptr * fperc;
  61.       if (newrgb > 255)
  62.     newrgb= 255;
  63.       *(destptr++)= newrgb;
  64.     }
  65.     break;
  66.   }
  67.   if (verbose)
  68.     printf("done\n");
  69. }
  70.  
  71. void gammacorrect(image, disp_gam, verbose)
  72.      Image        *image;
  73.      float  disp_gam;
  74.      unsigned int  verbose;
  75. { int          a;
  76.   int gammamap[256];
  77.   unsigned int size;
  78.   byte        *destptr;
  79.  
  80.   goodImage(image, "gammacorrect");
  81.   if (BITMAPP(image)) /* we're AT&T */
  82.     return;
  83.  
  84.   if (verbose) {
  85.     printf("  Adjusting colormap for display gamma of %4.2f...", disp_gam);
  86.     fflush(stdout);
  87.   }
  88.  
  89.   make_gamma(disp_gam,gammamap);
  90.  
  91.   switch (image->type) {
  92.   case IRGB:
  93.     for (a= 0; a < image->rgb.used; a++) {
  94.       *(image->rgb.red + a)= gammamap[(*(image->rgb.red + a))>>8]<<8;
  95.       *(image->rgb.green + a)= gammamap[(*(image->rgb.green + a))>>8]<<8;
  96.       *(image->rgb.blue + a)= gammamap[(*(image->rgb.blue + a))>>8]<<8;
  97.     }
  98.     break;
  99.  
  100.   case ITRUE:
  101.     size= image->width * image->height * 3;
  102.     destptr= image->data;
  103.     for (a= 0; a < size; a++) {
  104.       *destptr= gammamap[*destptr];
  105.       destptr++;
  106.     }
  107.     break;
  108.   }
  109.  
  110.   if (verbose)
  111.     printf("done\n");
  112. }
  113.  
  114. /* this initializes a lookup table for doing normalization
  115.  */
  116.  
  117. static void setupNormalizationArray(min, max, array, verbose)
  118.      unsigned int min, max;
  119.      byte *array;
  120.      unsigned int verbose;
  121. { int a;
  122.   unsigned int new;
  123.   float factor;
  124.  
  125.   if (verbose) {
  126.     printf("scaling %d:%d to 0:255...", min, max);
  127.     fflush(stdout);
  128.   }
  129.   factor= 256.0 / (max - min);
  130.   for (a= min; a <= max; a++) {
  131.     new= (float)(a - min) * factor;
  132.     array[a]= (new > 255 ? 255 : new);
  133.   }
  134. }
  135.  
  136. /* normalize an image.
  137.  */
  138.  
  139. Image *normalize(image, verbose)
  140.      Image        *image;
  141.      unsigned int  verbose;
  142. { unsigned int  a, x, y;
  143.   unsigned int  min, max;
  144.   Pixel         pixval;
  145.   Image        *newimage;
  146.   byte         *srcptr, *destptr;
  147.   byte          array[256];
  148.  
  149.   goodImage(image);
  150.   if (BITMAPP(image))
  151.     return(image);
  152.  
  153.   if (verbose) {
  154.     printf("  Normalizing...");
  155.     fflush(stdout);
  156.   }
  157.   switch (image->type) {
  158.   case IRGB:
  159.     min= 256;
  160.     max = 0;
  161.     for (a= 0; a < image->rgb.used; a++) {
  162.       byte red, green, blue;
  163.  
  164.       red= image->rgb.red[a] >> 8;
  165.       green= image->rgb.green[a] >> 8;
  166.       blue= image->rgb.blue[a] >> 8;
  167.       if (red < min)
  168.     min= red;
  169.       if (red > max)
  170.     max= red;
  171.       if (green < min)
  172.     min= green;
  173.       if (green > max)
  174.     max= green;
  175.       if (blue < min)
  176.     min= blue;
  177.       if (blue > max)
  178.     max= blue;
  179.     }
  180.     setupNormalizationArray(min, max, array, verbose);
  181.  
  182.     newimage= newTrueImage(image->width, image->height);
  183.     srcptr= image->data;
  184.     destptr= newimage->data;
  185.     for (y= 0; y < image->height; y++)
  186.       for (x= 0; x < image->width; x++) {
  187.     pixval= memToVal(srcptr, image->pixlen);
  188.     *destptr= array[image->rgb.red[pixval] >> 8];
  189.     *destptr++;
  190.     *destptr= array[image->rgb.green[pixval] >> 8];
  191.     *destptr++;
  192.     *destptr= array[image->rgb.blue[pixval] >> 8];
  193.     *destptr++;
  194.     srcptr += image->pixlen;
  195.       }
  196.     break;
  197.  
  198.   case ITRUE:
  199.     srcptr= image->data;
  200.     min= 255;
  201.     max= 0;
  202.     for (y= 0; y < image->height; y++)
  203.       for (x= 0; x < image->width; x++) {
  204.     if (*srcptr < min)
  205.       min= *srcptr;
  206.     if (*srcptr > max)
  207.       max= *srcptr;
  208.     srcptr++;
  209.     if (*srcptr < min)
  210.       min= *srcptr;
  211.     if (*srcptr > max)
  212.       max= *srcptr;
  213.     srcptr++;
  214.     if (*srcptr < min)
  215.       min= *srcptr;
  216.     if (*srcptr > max)
  217.       max= *srcptr;
  218.     srcptr++;
  219.       }
  220.     setupNormalizationArray(min, max, array, verbose);
  221.  
  222.     srcptr= image->data;
  223.     for (y= 0; y < image->height; y++)
  224.       for (x= 0; x < image->width; x++) {
  225.     *srcptr= array[*srcptr];
  226.     srcptr++;
  227.     *srcptr= array[*srcptr];
  228.     srcptr++;
  229.     *srcptr= array[*srcptr];
  230.     srcptr++;
  231.       }
  232.     newimage= image;
  233.   }
  234.  
  235.   if (verbose)
  236.     printf("done\n");
  237.   return(newimage);
  238. }
  239.  
  240. /* convert to grayscale
  241.  */
  242.  
  243. void gray(image, verbose)
  244.      Image *image;
  245. { int a;
  246.   unsigned int size;
  247.   Intensity intensity, red, green, blue;
  248.   byte *destptr;
  249.  
  250.   goodImage(image, "gray");
  251.   if (BITMAPP(image))
  252.     return;
  253.  
  254.   if (verbose) {
  255.     printf("  Converting image to grayscale...");
  256.     fflush(stdout);
  257.   }
  258.   switch (image->type) {
  259.   case IRGB:
  260.     for (a= 0; a < image->rgb.used; a++) {
  261.       intensity= colorIntensity(image->rgb.red[a],
  262.                 image->rgb.green[a],
  263.                 image->rgb.blue[a]);
  264.       image->rgb.red[a]= intensity;
  265.       image->rgb.green[a]= intensity;
  266.       image->rgb.blue[a]= intensity;
  267.     }
  268.     break;
  269.  
  270.   case ITRUE:
  271.     size= image->width * image->height;
  272.     destptr= image->data;
  273.     for (a= 0; a < size; a++) {
  274.       red= *destptr << 8;
  275.       green= *(destptr + 1) << 8;
  276.       blue= *(destptr + 2) << 8;
  277.       intensity= colorIntensity(red, green, blue) >> 8;
  278.       *(destptr++)= intensity; /* red */
  279.       *(destptr++)= intensity; /* green */
  280.       *(destptr++)= intensity; /* blue */
  281.     }
  282.     break;
  283.   }
  284.   if (verbose)
  285.     printf("done\n");
  286. }
  287.